/**
 * @file config.cpp
 * @brief 配置管理系统实现，用于管理配置和存储（使用Preferences库）
 */

#include "../include/config.h"
#include <Preferences.h>

// 创建Preferences对象
Preferences preferences;

// 全局配置变量定义
Config g_config;
bool colorRandomSwitch = false; // 全局随机颜色开关
uint8_t currentRainbowDirection = 0;

// 配置范围定义
const ConfigRange g_configRanges[CONFIG_COUNT] = {
    // 基础配置 (0-12)
    {0, MAX_EFFECT_TYPES - 1, 3},        // CONFIG_EFFECT_TYPE - 效果类型(0-7, 默认频谱模式)
    {0, MAX_COLOR_SCHEMES - 1, 0},       // CONFIG_COLOR_SCHEME - 颜色方案(0-5, 默认彩虹色)
    {10, 100, 10, 10},                   // CONFIG_BRIGHTNESS - 亮度(10-100%, 默认10%, 步进10%)
    {10, 100, 35, 5},                    // CONFIG_SENSITIVITY - 音频灵敏度(10-100%, 默认35%, 步进5%)
    {0, LED_STRIP_MODE_COUNT - 1, LED_MODE_WALL, 1}, // CONFIG_LED_STRIP_MODE - 灯带模式(0=墙模式, 1=流水模式)
    {1, 32, 32, 1},                      // CONFIG_SEGMENTS - 灯带分段数(1-32段, 默认32段)
    {1, 64, 32, 1},                      // CONFIG_LEDS_PER_SEGMENT - 每段LED数(1-64个, 默认32个)
    {0, MAX_STYLES - 1, 0, 1},           // CONFIG_STYLE - 灯光样式(0-7种样式, 默认样式0)
    {10, 100, 50, 10},                   // CONFIG_SPEED - 效果速度(10-100%, 默认50%, 步进10%)
    {0, 1, 0},                           // CONFIG_AUTO_CHANGE_EFFECT - 自动切换效果(0=关闭, 1=开启)
    {1, 60, 5},                          // CONFIG_AUTO_CHANGE_TIME - 自动切换时间(1-60分钟, 默认5分钟)
    {0, 20, 5, 1},                       // CONFIG_MIN_THRESHOLD - 最小显示阈值(0-20%, 默认5%, 对应0.05)
    {0, 1, 0},                           // CONFIG_NOISE_CHECK - 噪声检查开关(0=关闭, 1=开启)
    
    // 频谱处理参数 (13-23)
    {0, 100, 60, 5},                     // CONFIG_SPECTRUM_SMOOTHING - 频谱平滑系数(0-100%, 默认25%, 控制频谱响应速度)
    {0, 100, 60, 5},                     // CONFIG_RISE_SPEED - 频谱上升速度(0-100%, 默认10%, 控制灯柱上升快慢)
    {0, 100, 60, 5},                     // CONFIG_FALL_SPEED - 频谱下降速度(0-100%, 默认30%, 控制灯柱回落快慢)
    {0, 100, 10, 5},                     // CONFIG_PEAK_DECAY - 峰值衰减速度(0-100%, 默认15%, 控制峰值保持时间)
    {0, 100, 85, 5},                     // CONFIG_PEAK_DOT_DECAY - 峰值点衰减速度(0-100%, 默认15%, 控制峰值点消失速度)
    {0, 100, 2, 1},                     // CONFIG_PEAK_HOLD_TIME - 峰值点停留时间(0-100%, 默认5%, 控制峰值点显示时长)
    {0, 100, 50, 5},                     // CONFIG_IMPACT_SPEED - 冲击速度(0-100%, 默认50%, 控制节拍冲击强度)
    {1, 20, 5, 1},                       // CONFIG_MAX_IMPACT_DISTANCE - 最大冲击距离(1-20个LED, 默认5个, 控制冲击范围)
    {5, 60, 10, 1},                      // CONFIG_COLOR_CYCLE_TIME - 颜色循环时间(5-60分钟, 默认10分钟, 控制颜色变化周期)
    {100, 255, 150, 10},                 // CONFIG_LOG_SCALE - 对数尺度系数(100-255%, 默认150%, 控制频谱压缩强度)
    {0, 100, 50, 5},                     // CONFIG_FAST_DECAY_RATE - 快速衰减率(0-100%, 默认50%, 静音时快速回落)
    
    // 频率补偿参数 (24-27) - 修复默认值与注释的一致性
    {10, 200, 100, 5},                   // CONFIG_LOW_FREQ_COMP (索引24) - 低频补偿(10-200%, 默认100%, 控制20Hz-200Hz显示强度)
    {10, 200, 120, 5},                   // CONFIG_MID_FREQ_COMP (索引25) - 中频补偿(10-200%, 默认120%, 控制200Hz-2kHz显示强度)
    {10, 200, 180, 5},                   // CONFIG_HIGH_MID_FREQ_COMP (索引26) - 中高频补偿(10-200%, 默认180%, 控制2kHz-10kHz显示强度)
    {10, 200, 200, 5},                   // CONFIG_HIGH_FREQ_COMP (索引27) - 高频补偿(10-200%, 默认200%, 控制10kHz-20kHz显示强度)
    
    // 噪声阈值参数 (28-31) - 修复默认值与注释的一致性
    {10, 100, 60, 5},                    // CONFIG_LOW_FREQ_NOISE - 低频噪声阈值(10-100%, 默认60%, 过滤20Hz-200Hz噪声)
    {10, 100, 50, 5},                    // CONFIG_MID_FREQ_NOISE - 中频噪声阈值(10-100%, 默认50%, 过滤200Hz-2kHz噪声)
    {10, 100, 60, 5},                    // CONFIG_HIGH_MID_FREQ_NOISE - 中高频噪声阈值(10-100%, 默认60%, 过滤2kHz-10kHz噪声)
    {10, 100, 50, 5},                    // CONFIG_HIGH_FREQ_NOISE - 高频噪声阈值(10-100%, 默认50%, 过滤10kHz-20kHz噪声)
    
    // 频谱压缩 (32)
    {80, 98, 95, 1},                     // CONFIG_SPECTRUM_COMPRESSION - 频谱压缩比例(80-98%, 默认95%, 控制动态范围压缩)
    
    // 动态频段分配 (33-36)
    {1, 50, 16, 1},                      // CONFIG_BASS_BANDS - 低频频段数(1-50段, 默认60段, 控制20Hz-200Hz分配)
    {1, 40, 10, 1},                      // CONFIG_MID_BANDS - 中频频段数(1-40段, 默认40段, 控制200Hz-2kHz分配)
    {1, 35, 4, 1},                      // CONFIG_HIGH_MID_BANDS - 中高频频段数(1-35段, 默认30段, 控制2kHz-10kHz分配)
    {1, 20, 2, 1},                       // CONFIG_HIGH_BANDS - 高频频段数(1-20段, 默认5段, 控制10kHz-20kHz分配)
    
    // 节拍检测参数 (37-41)
    {10, 100, 90, 5},                    // CONFIG_BEAT_SENSITIVITY - 节拍灵敏度(10-100, 默认90, 控制节拍检测敏感度)
    {10, 200, 40, 5},                    // CONFIG_BEAT_THRESHOLD - 节拍阈值(10-200%, 默认40%, 控制节拍触发阈值)
    {10, 100, 20, 5},                    // CONFIG_BEAT_DECAY_RATE - 节拍衰减率(10-100%, 默认30%, 控制节拍信号衰减速度)
    {50, 255, 120, 10},                  // CONFIG_BEAT_MIN_INTERVAL - 节拍间隔(50-255ms, 默认180ms, 防止过度触发)
    {100, 255, 250, 25},                 // CONFIG_BEAT_BOOST_FACTOR - 节拍增强因子(100-255%, 默认250%, 控制节拍视觉增强倍数)
    
    // 频率上限 (42)
    {10, 48, 20, 1},                     // CONFIG_FREQ_UPPER_LIMIT - 频率上限(10-48kHz, 默认20kHz, 控制频谱分析最高频率)
    
    // FFT窗函数 (43)
    {0, 3, 1, 1},                        // CONFIG_FFT_WINDOW_TYPE - FFT窗函数类型(0=Rectangle, 1=Hamming, 2=Hann, 3=Blackman, 默认Hamming)
    
    // 峰值点配置 (44-45)
    {0, 2, 2, 1},                        // CONFIG_PEAK_DOT_COUNT - 峰值点数量(0=关闭, 1=1个, 2=2个, 默认1个)
    {0, 9, 0, 1},                        // CONFIG_PEAK_DOT_COLOR - 峰值点颜色(0=七彩, 1-9=单色, 默认七彩)
    
    // 音量自适应 (46)
    {0, 1, 1, 1},                        // CONFIG_VOLUME_ADAPTIVE - 音量自适应开关(0=关闭, 1=开启, 默认开启)
    
    // 七彩和渐变参数 (47-52)
    {0, 6, 0, 1},                        // CONFIG_RAINBOW_TYPE - 七彩颜色类型(0-6: 全彩,冷色,暖色,粉色,青色,紫色,随机色, 默认全彩)
    {1, 100, 30, 1},                     // CONFIG_RAINBOW_SPEED - 七彩颜色速度(1-100%, 默认50%, 控制颜色变化速度)
    {1, 100, 50, 1},                     // CONFIG_RAINBOW_SMOOTH - 七彩颜色平滑(1-100%, 默认50%, 控制颜色过渡平滑度)
    {0, 15, 0, 1},                        // CONFIG_RAINBOW_DIRECTION - 七彩颜色方向(0-9: 上-下,下-上,左-右,右-左,强烈闪烁脉冲,彩虹爆炸效果,环形流动,极光扫描,霓虹闪电,波浪流动, 默认上-下)
    {1, 100, 50, 1},                     // CONFIG_GRADIENT_SPEED - 渐变颜色速度(1-100%, 默认50%, 控制渐变变化速度)
    {1, 100, 50, 1},                     // CONFIG_GRADIENT_SMOOTH - 渐变颜色平滑(1-100%, 默认50%, 控制渐变过渡平滑度)
    {0, 255, 120, 1}                     // CONFIG_SOLID_COLOR_HUE - 单色色调 (0-255, 默认120度蓝绿色)
};

// 配置管理函数实现
const ConfigRange &getConfigRange(ConfigItem item)
{
    return g_configRanges[item];
}

int16_t clampConfigValue(ConfigItem item, int16_t value)
{
    const ConfigRange &range = getConfigRange(item);
    if (value < range.min)
        return range.min;
    if (value > range.max)
        return range.max;
    return value;
}

int16_t getConfigDefault(ConfigItem item)
{
    return getConfigRange(item).def;
}

/**
 * @brief 重置配置为默认值
 *
 * @return true 重置成功
 * @return false 重置失败
 */
bool resetConfig()
{
    // 设置默认值
    g_config.magicNumber = CONFIG_VALID_MARKER;
    g_config.effectType = getConfigDefault(CONFIG_EFFECT_TYPE);
    g_config.colorScheme = getConfigDefault(CONFIG_COLOR_SCHEME);
    g_config.brightness = getConfigDefault(CONFIG_BRIGHTNESS);
    g_config.sensitivity = getConfigDefault(CONFIG_SENSITIVITY);
    g_config.ledStripMode = getConfigDefault(CONFIG_LED_STRIP_MODE);
    g_config.segments = getConfigDefault(CONFIG_SEGMENTS);
    g_config.ledsPerSegment = getConfigDefault(CONFIG_LEDS_PER_SEGMENT);
    g_config.style = getConfigDefault(CONFIG_STYLE);
    g_config.speed = getConfigDefault(CONFIG_SPEED);
    g_config.autoChangeEffect = getConfigDefault(CONFIG_AUTO_CHANGE_EFFECT) > 0;
    g_config.autoChangeTime = getConfigDefault(CONFIG_AUTO_CHANGE_TIME) * 1000; // 转换为毫秒

    // 设置音柱段数默认值
    g_config.segments = getConfigDefault(CONFIG_SEGMENTS);
    g_config.noiseCheckEnabled = getConfigDefault(CONFIG_NOISE_CHECK) > 0;
    g_config.minThreshold = getConfigDefault(CONFIG_MIN_THRESHOLD) / 100.0f; // 转换为0.0-0.2范围
    if (isnan(g_config.minThreshold))
    {
        g_config.minThreshold = 0.05f; // 强制设置默认值
        if (DEBUG_SERIAL)
        {
            Serial.println("警告: minThreshold初始化失败，使用默认值0.05");
        }
    }

    // 初始化新增的频谱平滑处理参数 (将0-100%范围转换为实际使用的浮点数)
    g_config.spectrumSmoothing = getConfigDefault(CONFIG_SPECTRUM_SMOOTHING) / 100.0f;  // 使用配置默认值25%->0.25f
    g_config.riseSpeed = getConfigDefault(CONFIG_RISE_SPEED) / 100.0f;                  // 使用配置默认值10%->0.10f
    g_config.fallSpeed = getConfigDefault(CONFIG_FALL_SPEED) / 100.0f;                  // 使用配置默认值30%->0.30f
    g_config.peakDecay = getConfigDefault(CONFIG_PEAK_DECAY) / 100.0f;                  // 使用配置默认值15%->0.15f
    g_config.peakDotDecay = getConfigDefault(CONFIG_PEAK_DOT_DECAY) / 100.0f;           // 使用配置默认值15%->0.15f
    g_config.peakHoldTime = getConfigDefault(CONFIG_PEAK_HOLD_TIME) / 100.0f;           // 使用配置默认值80%->0.8f
    g_config.impactSpeed = getConfigDefault(CONFIG_IMPACT_SPEED) / 10.0f;               // 使用配置默认值50%->5.0f (除以10转换为0-10.0范围)
    g_config.maxImpactDistance = getConfigDefault(CONFIG_MAX_IMPACT_DISTANCE);          // 使用配置默认值5个LED
    g_config.colorCycleTime = getConfigDefault(CONFIG_COLOR_CYCLE_TIME) * 60000;        // 10分钟->600000毫秒 (分钟转毫秒)
    g_config.logScale = getConfigDefault(CONFIG_LOG_SCALE) / 100.0f;                   // 1.5 (150%->1.5)
    g_config.fastDecayRate = getConfigDefault(CONFIG_FAST_DECAY_RATE) / 100.0f;        // 0.5

    // FFT处理相关参数 - 修复归一化参数
    g_config.minBandValue = 0.0f;         // 频段最小值(用于归一化)
    g_config.maxBandValue = 10.0f;        // 增大最大值范围
    g_config.normalizationFactor = 0.05f; // 大幅降低归一化因子
    g_config.debugNormalization = true;   // 启用归一化调试开关

    // ==================== 初始化频率补偿参数 ====================
    // 这四个参数控制不同频段的补偿系数，用户可在菜单中调整
    // 配置范围：50-200%，实际使用时转换为0.5-2.0倍数
    // 补偿原理：
    //   - 低频段(0-29, 20Hz-200Hz)：通常能量较高，默认衰减到80%
    //   - 中频段(30-69, 200Hz-2kHz)：人耳敏感频段，保持100%原值
    //   - 中高频段(70-109, 2kHz-10kHz)：适度补偿到120%
    //   - 高频段(110-119, 10kHz-20kHz)：衰减严重，补偿到150%

    // 将50-200%范围转换为0.5-2.0浮点数
    g_config.lowFreqComp = getConfigDefault(CONFIG_LOW_FREQ_COMP) / 100.0f;          // 0.8 (80%->0.8)
    g_config.midFreqComp = getConfigDefault(CONFIG_MID_FREQ_COMP) / 100.0f;          // 1.0 (100%->1.0)
    g_config.highMidFreqComp = getConfigDefault(CONFIG_HIGH_MID_FREQ_COMP) / 100.0f; // 1.2 (120%->1.2)
    g_config.highFreqComp = getConfigDefault(CONFIG_HIGH_FREQ_COMP) / 100.0f;        // 1.5 (150%->1.5)

    // ==================== 初始化分频段噪声阈值参数 ====================
    // 这四个参数控制不同频段的噪声过滤强度，用户可在菜单中调整
    // 配置范围：10-100%，实际使用时转换为0.01-1.0倍数
    // 噪声过滤原理：
    //   - 低频段(0-29, 20Hz-200Hz)：噪声较多，默认30%（较严格过滤）
    //   - 中频段(30-69, 200Hz-2kHz)：噪声中等，默认50%（中等过滤）
    //   - 中高频段(70-109, 2kHz-10kHz)：噪声较少，默认70%（较宽松过滤）
    //   - 高频段(110-119, 10kHz-20kHz)：噪声最少，默认80%（最宽松过滤）

    // 将10-100%范围转换为0.01-1.0浮点数
    g_config.lowFreqNoise = getConfigDefault(CONFIG_LOW_FREQ_NOISE) / 100.0f;          // 0.3 (30%->0.3)
    g_config.midFreqNoise = getConfigDefault(CONFIG_MID_FREQ_NOISE) / 100.0f;          // 0.5 (50%->0.5)
    g_config.highMidFreqNoise = getConfigDefault(CONFIG_HIGH_MID_FREQ_NOISE) / 100.0f; // 0.7 (70%->0.7)
    g_config.highFreqNoise = getConfigDefault(CONFIG_HIGH_FREQ_NOISE) / 100.0f;        // 0.8 (80%->0.8)

    // ==================== 初始化频谱压缩比例参数 ====================
    // 频谱压缩比例控制动态范围压缩，范围80%-98%
    // 数值越高，压缩越轻微；数值越低，压缩越强烈
    // 默认90%提供了较好的动态范围和细节平衡
    g_config.spectrumCompression = getConfigDefault(CONFIG_SPECTRUM_COMPRESSION) / 100.0f; // 0.9 (90%->0.9)

    // ==================== 初始化动态频段分配参数 ====================
    // 这四个参数控制低音、中音、中高音、高音的频段分配数量
    // 用户可以根据音乐类型和个人喜好在菜单中调整
    g_config.bassBands = getConfigDefault(CONFIG_BASS_BANDS);        // 20个低频频段(20Hz-200Hz)
    g_config.midBands = getConfigDefault(CONFIG_MID_BANDS);          // 30个中频频段(200Hz-2kHz)
    g_config.highMidBands = getConfigDefault(CONFIG_HIGH_MID_BANDS); // 35个中高频频段(2kHz-10kHz)
    g_config.highBands = getConfigDefault(CONFIG_HIGH_BANDS);        // 15个高频频段(10kHz-20kHz)

    // ==================== 初始化节拍检测参数 ====================
    // 这五个参数控制节拍检测和视觉增强效果
    // 用户可以在菜单中调整节拍检测的敏感度和视觉响应强度
    g_config.beatSensitivity = getConfigDefault(CONFIG_BEAT_SENSITIVITY);           // 60 (节拍检测敏感度)
    g_config.beatThreshold = getConfigDefault(CONFIG_BEAT_THRESHOLD) / 100.0f;      // 0.8 (80%->0.8, 节拍检测阈值)
    g_config.beatDecayRate = getConfigDefault(CONFIG_BEAT_DECAY_RATE) / 100.0f;     // 0.3 (30%->0.3, 节拍衰减率)
    g_config.beatMinInterval = getConfigDefault(CONFIG_BEAT_MIN_INTERVAL);          // 150ms (最小节拍间隔)
    g_config.beatBoostFactor = getConfigDefault(CONFIG_BEAT_BOOST_FACTOR) / 100.0f; // 2.5 (250%->2.5, 节拍增强因子)

    // ==================== 新增频率上限调整 ====================
    // 频率上限参数控制频谱分析的最高频率，范围10kHz-48kHz
    // 存储方式：直接存储kHz值
    // 实际频率 = 存储值 * 1000
    g_config.freqUpperLimit = getConfigDefault(CONFIG_FREQ_UPPER_LIMIT) * 1000; // 将kHz转换为Hz存储

    // ==================== 新增FFT窗函数选择 ====================
    // FFT窗函数类型参数控制FFT分析时使用的窗函数，影响频域平滑度
    // 0=Rectangle, 1=Hamming, 2=Hann, 3=Blackman，默认Hamming
    g_config.fftWindowType = getConfigDefault(CONFIG_FFT_WINDOW_TYPE); // 默认1(Hamming窗)

    // ==================== 新增峰值点配置参数初始化 ====================
    g_config.peakDotCount = getConfigDefault(CONFIG_PEAK_DOT_COUNT);  // 默认1个峰值点
    g_config.peakDotColor = getConfigDefault(CONFIG_PEAK_DOT_COLOR);  // 默认七彩颜色

    // ==================== 新增音量自适应开关初始化 ====================
    g_config.volumeAdaptive = getConfigDefault(CONFIG_VOLUME_ADAPTIVE) > 0;  // 默认开启音量自适应

    // ==================== 七彩相关参数安全初始化 ====================
    // 修复内存越界问题：确保按照结构体顺序和范围安全初始化
    g_config.rainbowType      = clampConfigValue(CONFIG_RAINBOW_TYPE, getConfigDefault(CONFIG_RAINBOW_TYPE));
    g_config.rainbowSpeed     = clampConfigValue(CONFIG_RAINBOW_SPEED, getConfigDefault(CONFIG_RAINBOW_SPEED));
    g_config.rainbowSmooth    = clampConfigValue(CONFIG_RAINBOW_SMOOTH, getConfigDefault(CONFIG_RAINBOW_SMOOTH));
    g_config.rainbowDirection = clampConfigValue(CONFIG_RAINBOW_DIRECTION, getConfigDefault(CONFIG_RAINBOW_DIRECTION));
    
    // 渐变相关参数
    g_config.gradientSpeed    = clampConfigValue(CONFIG_GRADIENT_SPEED, getConfigDefault(CONFIG_GRADIENT_SPEED));
    g_config.gradientSmooth   = clampConfigValue(CONFIG_GRADIENT_SMOOTH, getConfigDefault(CONFIG_GRADIENT_SMOOTH));
    
    // 单色相关参数
    g_config.solidColorHue    = clampConfigValue(CONFIG_SOLID_COLOR_HUE, getConfigDefault(CONFIG_SOLID_COLOR_HUE));

    if (DEBUG_SERIAL)
    {
        Serial.println("配置已重置为默认值");
        
        // 添加七彩参数的调试输出
        Serial.printf("七彩参数初始化: 类型=%d, 速度=%d, 平滑=%d, 方向=%d\n",
                      g_config.rainbowType, g_config.rainbowSpeed, g_config.rainbowSmooth, g_config.rainbowDirection);
        Serial.printf("渐变参数初始化: 速度=%d, 平滑=%d\n",
                      g_config.gradientSpeed, g_config.gradientSmooth);
        Serial.printf("单色参数初始化: 色调=%d\n", g_config.solidColorHue);
        
        // ...existing debug code...
    }

    return true;
}

// 使用Preferences库，不需要定义起始地址

// 使用config.h中定义的CONFIG_VALID_MARKER

// 存储命名空间
#define PREF_NAMESPACE "ledconfig"
#define CONFIG_KEY "config"
#define MODE_KEY "mode"

/**
 * @brief 初始化存储系统
 *
 * @return true 初始化成功
 * @return false 初始化失败
 */
bool initStorage()
{
    if (DEBUG_SERIAL)
    {
        Serial.println("初始化Preferences存储...");
    }

    // 打开Preferences命名空间
    if (!preferences.begin(PREF_NAMESPACE, false))
    {
        if (DEBUG_SERIAL)
        {
            Serial.println("初始化Preferences失败!");
        }
        return false;
    }

    if (DEBUG_SERIAL)
    {
        Serial.println("初始化Preferences成功!");
    }
    return true;
}

// 通用存储函数实现 - 使用Preferences
uint8_t readFromStorage(uint16_t address)
{
    // 这个函数不再使用地址，而是使用键值对
    // 为了兼容性，我们可以将地址转换为字符串键
    char key[16];
    sprintf(key, "addr_%d", address);
    return preferences.getUChar(key, 0);
}

void writeToStorage(uint16_t address, uint8_t value)
{
    // 这个函数不再使用地址，而是使用键值对
    char key[16];
    sprintf(key, "addr_%d", address);
    preferences.putUChar(key, value);
}

/**
 * @brief 保存配置到Preferences存储
 *
 * @return true 保存成功
 * @return false 保存失败
 */
bool saveConfig()
{
    Serial.println("[配置保存] 开始保存配置到Preferences存储...");
    Serial.printf("[配置保存] 配置数据大小: %d 字节\n", sizeof(g_config));

    // 确保Preferences已关闭并重新打开，以避免潜在的缓存问题
    preferences.end();
    if (!preferences.begin(PREF_NAMESPACE, false))
    {
        Serial.println("[配置保存] 错误: 无法打开Preferences命名空间!");
        return false;
    }

    // 保存配置有效性标记
    preferences.putUChar("valid", CONFIG_VALID_MARKER);

    // 保存整个配置结构
    size_t bytesWritten = preferences.putBytes(CONFIG_KEY, &g_config, sizeof(g_config));

    // 单独保存一些关键配置，方便快速访问
    preferences.putUChar("effectType", g_config.effectType);
    preferences.putUChar("segments", g_config.segments);

    // 提交更改
    preferences.end();

    // 重新打开Preferences以供后续使用
    preferences.begin(PREF_NAMESPACE, false);

    if (bytesWritten == sizeof(g_config))
    {
        Serial.println("[配置保存] 配置保存成功!");
        Serial.printf("[配置保存] 保存的模式: %d\n", g_config.effectType);
        Serial.printf("[配置保存] 保存的段数: %d\n", g_config.segments);
        return true;
    }
    else
    {
        Serial.println("[配置保存] 错误: 配置保存失败!");
        Serial.printf("[配置保存] 预期写入 %d 字节，实际写入 %d 字节\n", sizeof(g_config), bytesWritten);
        return false;
    }
}

/**
 * @brief 从Preferences存储加载配置
 *
 * @return true 加载成功
 * @return false 加载失败
 */
bool loadConfig()
{
    Serial.println("[配置加载] 开始从Preferences存储加载配置...");

    // 确保Preferences已关闭并重新打开，以避免潜在的缓存问题
    preferences.end();
    if (!preferences.begin(PREF_NAMESPACE, false))
    {
        Serial.println("[配置加载] 错误: 无法打开Preferences命名空间!");
        return false;
    }

    // 检查配置有效性标记
    if (preferences.getUChar("valid", 0) != CONFIG_VALID_MARKER)
    {
        if (DEBUG_SERIAL)
        {
            Serial.println("[配置加载] Preferences存储中无有效配置!");
        }
        return false;
    }

    // 读取整个配置结构
    size_t bytesRead = preferences.getBytes(CONFIG_KEY, &g_config, sizeof(g_config));

    if (bytesRead != sizeof(g_config))
    {
        if (DEBUG_SERIAL)
        {
            Serial.println("[配置加载] 配置加载失败: 数据大小不匹配!");
            Serial.printf("[配置加载] 预期读取 %d 字节，实际读取 %d 字节\n", sizeof(g_config), bytesRead);
        }
        resetConfig();
        return false;
    }

    // 强制验证LED配置范围
    if (g_config.segments > 32 || g_config.ledsPerSegment > 64)
    {
        if (DEBUG_SERIAL)
        {
            Serial.println("[配置加载] 检测到无效LED配置，重置为默认值!");
            Serial.printf("[配置加载] 当前段数: %d (最大32)\n", g_config.segments);
            Serial.printf("[配置加载] 每段LED数: %d (最大64)\n", g_config.ledsPerSegment);
        }
        resetConfig();
        saveConfig();
        return false;
    }

    if (DEBUG_SERIAL)
    {
        Serial.println("[配置加载] 配置加载成功!");
        Serial.println("==================== 完整配置信息 ====================");
        
        // 基础配置
        Serial.printf("[基础配置] 魔数: 0x%02X\n", g_config.magicNumber);
        Serial.printf("[基础配置] 效果类型: %d\n", g_config.effectType);
        Serial.printf("[基础配置] 颜色方案: %d\n", g_config.colorScheme);
        Serial.printf("[基础配置] 亮度: %d%%\n", g_config.brightness);
        Serial.printf("[基础配置] 灵敏度: %d%%\n", g_config.sensitivity);
        Serial.printf("[基础配置] 灯带模式: %d (%s)\n", g_config.ledStripMode, 
                      g_config.ledStripMode == LED_MODE_WALL ? "灯带墙" : "流水灯");
        Serial.printf("[基础配置] LED段数: %d\n", g_config.segments);
        Serial.printf("[基础配置] 每段LED数: %d\n", g_config.ledsPerSegment);
        Serial.printf("[基础配置] 总LED数: %d\n", g_config.segments * g_config.ledsPerSegment);
        Serial.printf("[基础配置] 风格: %d\n", g_config.style);
        Serial.printf("[基础配置] 速度: %d%%\n", g_config.speed);
        Serial.printf("[基础配置] 自动切换效果: %s\n", g_config.autoChangeEffect ? "开启" : "关闭");
        Serial.printf("[基础配置] 自动切换时间: %d秒\n", g_config.autoChangeTime / 1000);
        Serial.printf("[基础配置] 最小显示阈值: %.3f\n", g_config.minThreshold);
        Serial.printf("[基础配置] 噪声检查: %s\n", g_config.noiseCheckEnabled ? "开启" : "关闭");
        
        // 频谱处理参数
        Serial.println("==================== 频谱处理参数 ====================");
        Serial.printf("[频谱处理] 频谱平滑系数: %.3f\n", g_config.spectrumSmoothing);
        Serial.printf("[频谱处理] 上升速度: %.3f\n", g_config.riseSpeed);
        Serial.printf("[频谱处理] 下降速度: %.3f\n", g_config.fallSpeed);
        Serial.printf("[频谱处理] 峰值衰减速度: %.3f\n", g_config.peakDecay);
        Serial.printf("[频谱处理] 峰值点衰减速度: %.3f\n", g_config.peakDotDecay);
        Serial.printf("[频谱处理] 峰值点停留时间: %.3f\n", g_config.peakHoldTime);
        Serial.printf("[频谱处理] 冲击速度: %.2f\n", g_config.impactSpeed);
        Serial.printf("[频谱处理] 最大冲击距离: %d个LED\n", g_config.maxImpactDistance);
        Serial.printf("[频谱处理] 颜色循环时间: %d秒\n", g_config.colorCycleTime / 1000);
        Serial.printf("[频谱处理] 对数尺度系数: %.2f\n", g_config.logScale);
        Serial.printf("[频谱处理] 快速衰减率: %.3f\n", g_config.fastDecayRate);
        
        // FFT处理参数
        Serial.println("==================== FFT处理参数 ====================");
        Serial.printf("[FFT处理] 频段最小值: %.3f\n", g_config.minBandValue);
        Serial.printf("[FFT处理] 频段最大值: %.3f\n", g_config.maxBandValue);
        Serial.printf("[FFT处理] 归一化因子: %.3f\n", g_config.normalizationFactor);
        Serial.printf("[FFT处理] 归一化调试: %s\n", g_config.debugNormalization ? "开启" : "关闭");
        
        // 频率补偿参数
        Serial.println("==================== 频率补偿参数 ====================");
        Serial.printf("[频率补偿] 低频补偿系数: %.2f (0-29段)\n", g_config.lowFreqComp);
        Serial.printf("[频率补偿] 中频补偿系数: %.2f (30-69段)\n", g_config.midFreqComp);
        Serial.printf("[频率补偿] 中高频补偿系数: %.2f (70-109段)\n", g_config.highMidFreqComp);
        Serial.printf("[频率补偿] 高频补偿系数: %.2f (110-119段)\n", g_config.highFreqComp);
        
        // 噪声阈值参数
        Serial.println("==================== 分频段噪声阈值参数 ====================");
        Serial.printf("[噪声阈值] 低频噪声阈值: %.3f (0-29段)\n", g_config.lowFreqNoise);
        Serial.printf("[噪声阈值] 中频噪声阈值: %.3f (30-69段)\n", g_config.midFreqNoise);
        Serial.printf("[噪声阈值] 中高频噪声阈值: %.3f (70-109段)\n", g_config.highMidFreqNoise);
        Serial.printf("[噪声阈值] 高频噪声阈值: %.3f (110-119段)\n", g_config.highFreqNoise);
        
        // 频谱压缩参数
        Serial.println("==================== 频谱压缩参数 ====================");
        Serial.printf("[频谱压缩] 压缩比例: %.3f (%.0f%%)\n", g_config.spectrumCompression, g_config.spectrumCompression * 100);
        
        // 动态频段分配参数
        Serial.println("==================== 动态频段分配参数 ====================");
        Serial.printf("[频段分配] 低频频段数: %d (20Hz-200Hz)\n", g_config.bassBands);
        Serial.printf("[频段分配] 中频频段数: %d (200Hz-2kHz)\n", g_config.midBands);
        Serial.printf("[频段分配] 中高频频段数: %d (2kHz-10kHz)\n", g_config.highMidBands);
        Serial.printf("[频段分配] 高频频段数: %d (10kHz-20kHz)\n", g_config.highBands);
        Serial.printf("[频段分配] 总频段数: %d\n", g_config.bassBands + g_config.midBands + g_config.highMidBands + g_config.highBands);
        
        // 节拍检测参数
        Serial.println("==================== 节拍检测参数 ====================");
        Serial.printf("[节拍检测] 灵敏度: %d\n", g_config.beatSensitivity);
        Serial.printf("[节拍检测] 阈值: %.3f\n", g_config.beatThreshold);
        Serial.printf("[节拍检测] 衰减率: %.3f\n", g_config.beatDecayRate);
        Serial.printf("[节拍检测] 最小间隔: %dms\n", g_config.beatMinInterval);
        Serial.printf("[节拍检测] 增强因子: %.2f\n", g_config.beatBoostFactor);
        
        // 频率上限参数
        Serial.println("==================== 频率上限参数 ====================");
        Serial.printf("[频率上限] 频率上限: %dkHz (%dHz)\n", g_config.freqUpperLimit / 1000, g_config.freqUpperLimit);
        
        // FFT窗函数参数
        Serial.println("==================== FFT窗函数参数 ====================");
        const char* windowNames[] = {"Rectangle", "Hamming", "Hann", "Blackman"};
        Serial.printf("[FFT窗函数] 窗函数类型: %d (%s)\n", g_config.fftWindowType, 
                      (g_config.fftWindowType < 4) ? windowNames[g_config.fftWindowType] : "Unknown");
        
        // 峰值点配置参数
        Serial.println("==================== 峰值点配置参数 ====================");
        const char* peakDotColors[] = {"七彩", "红色", "绿色", "蓝色", "黄色", "白色", "紫色", "青色", "橙色", "粉色"};
        Serial.printf("[峰值点配置] 峰值点数量: %d\n", g_config.peakDotCount);
        Serial.printf("[峰值点配置] 峰值点颜色: %d (%s)\n", g_config.peakDotColor, 
                      (g_config.peakDotColor < 10) ? peakDotColors[g_config.peakDotColor] : "Unknown");
        
        Serial.println("==================== 配置信息输出完成 ====================");
    }

    return true;
}

/**
 * @brief 重置Preferences存储中的配置为默认值
 *
 * @return true 重置成功
 * @return false 重置失败
 */
bool resetStoredConfig()
{
    // 清除配置有效性标记
    preferences.remove("valid");

    // 清除配置数据
    preferences.remove(CONFIG_KEY);

    // 清除单独保存的关键配置
    preferences.remove("effectType");
    preferences.remove("segments");

    // 重置内存中的配置
    resetConfig();

    // 保存到Preferences
    return saveConfig();
}

/**
 * @brief 检查Preferences存储中是否有有效配置
 *
 * @return true 有有效配置
 * @return false 无有效配置
 */
bool hasValidConfig()
{
    return preferences.getUChar("valid", 0) == CONFIG_VALID_MARKER;
}

bool saveModeToPreferences(uint8_t mode)
{
    if (mode >= MAX_EFFECT_TYPES)
    {
        if (DEBUG_SERIAL)
        {
            Serial.printf("错误: 无效的模式值 %d (最大 %d)\n", mode, MAX_EFFECT_TYPES - 1);
        }
        return false;
    }

    g_config.effectType = mode;

    if (DEBUG_SERIAL)
    {
        Serial.printf("正在保存模式 %d 到Preferences存储...\n", mode);
    }

    bool result = saveConfig();

    if (DEBUG_SERIAL)
    {
        if (result)
        {
            Serial.println("模式保存成功");
        }
        else
        {
            Serial.println("模式保存失败");
        }
    }

    return result;
}